# 思路：
# 递归判断对称性：从根节点开始，递归地比较左子树和右子树的每个节点
# 1.如果两个节点都为空，对称
# 2.如果一个节点为空而另一个节点不为空，不对称
# 3.如果两个节点的值不相等，不对称
# 4.递归比较左子树的左节点 和 右子树的右节点，以及 左子树的右节点 和 右子树的左节点

# 递归函数 judge，用于判断以 x 和 y 为根节点的两棵子树是否对称
def judge(x, y):
    # 声明使用全局变量 flag
    global flag
    # 如果 x 和 y 都为 -1，说明这两棵子树都为空，是对称的，直接返回
    if x == -1 and y == -1:
        return
    # 如果 x 和 y 其中一个为 -1，或者它们的值不相等，说明这两棵子树不对称，将 flag 置为 False 并返回
    if x == -1 or y == -1 or v[x] != v[y]:
        flag = False
        return
    # 递归判断 x 的左子树和 y 的右子树是否对称
    judge(l[x], r[y])
    # 递归判断 x 的右子树和 y 的左子树是否对称
    judge(r[x], l[y])


# 递归 dfs，计算以 root 为根节点的子树的节点数量
def dfs(root):
    # 如果根节点为 -1，说明该子树为空，节点数量为 0，返回 0
    if root == -1:
        return 0
    # 初始化节点为 1，即根节点本身
    k = 1
    # 如果根节点的左子节点存在，递归左子树
    if l[root]!=-1:
        k += dfs(l[root])
    # 如果根节点的右子节点存在，递归右子树
    if r[root]!=-1:
        k += dfs(r[root])
    # 返回以 root 为根节点的子树的节点数量
    return k

n = int(input())
# 定义 v,l,r数组 分别 存储 节点的值，节点的左节点，节点的右节点
v=[0]+list(map(int,input().split()))
l=[0]*(n+1)
r=[0]*(n+1)
for i in range(1, n + 1):
    l[i], r[i] = map(int, input().split())
print(l,r)
# 全局变量，用于标记子树是否对称
flag = True
ans = -1
# 遍历每个节点，判断以该节点为根节点的子树是否对称
for i in range(1, n + 1):
    # 每次判断前将 flag 置为 True
    flag = True
    # 调用 judge 函数判断该节点的左子树和右子树是否对称
    judge(l[i], r[i])
    # 对称
    if flag:
        # dfs 计算以该节点为根节点的子树的节点数量，并更新最大对称子树的节点数量
        ans = max(ans, dfs(i))
# 输出最大对称子树的节点数量
print(ans)
